//=============================================================================
// Drill_LayerCamera.js
//=============================================================================

/*:
 * @plugindesc [v1.8]        地圖 - 活動地圖鏡頭
 * @author Drill_up
 * 
 * @param 縮小鏡頭時是否加強刷新量
 * @type boolean
 * @on 加強
 * @off 關閉
 * @desc 地圖的圖塊是一塊塊拼上去的，如果縮小鏡頭，將看到更多的圖塊。設定後，強制刷新看得見的圖塊。
 * @default true
 *
 * @param 鏡頭移動模式
 * @type select
 * @option 默認移動
 * @value 默認移動
 * @option 平滑移動
 * @value 平滑移動
 * @option 彈性移動
 * @value 彈性移動
 * @desc 鏡頭移動到玩家位置的模式。
 * @default 彈性移動
 *
 * @param 彈性模式移動速度
 * @parent 鏡頭移動模式
 * @type number
 * @min 1
 * @desc 彈性模式的速度為比例除數，值越小，速度越快。
 * @default 14
 *
 * @param 彈性模式鏡頭速度上限
 * @parent 鏡頭移動模式
 * @type number
 * @min 1
 * @desc 彈性模式的最大速度，單位幀/像素。用於防止鏡頭移動速度太快，眼花。
 * @default 24
 * 
 * @help 
 * =============================================================================
 * +++ Drill_LayerCamera +++
 * 作者：Drill_up
 * 如果你有興趣，也可以來看看我的mog中文全翻譯插件哦ヽ(*。>Д<)o゜
 * https://rpg.blue/thread-409713-1-1.html
 * =============================================================================
 * 使得你可以操作地圖鏡頭的 鏡頭移動、鏡頭翻轉、鏡頭縮放/旋轉 功能。
 * 如果想了解鏡頭更多的內容，可以去看看"關於地圖活動鏡頭.docx"。
 * ★★最好放在 多層地圖背景 插件後面★★
 * 
 * -----------------------------------------------------------------------------
 * ----插件擴展
 * 該插件由於控制了鏡頭的縮放大小，對下列插件有一定影響：
 * 被擴展：
 *   - Drill_CoreOfMoveRoute   物體-移動路線核心
 *   - Drill_EventSound        物體-事件的聲音
 *   - Drill_MouseTriggerEvent 滑鼠-滑鼠觸發事件 ★★v1.3及以上版本★★
 *   - Drill_MouseGridPointer  滑鼠-網格指向標
 *   - Drill_MouseIllumination 滑鼠-自定義照明效果
 *   - Drill_OperateHud        互動-滑鼠輔助操作面板 ★★v1.6及以上版本★★
 *   - Drill_GaugeForVariable  UI - 高級變量固定框 ★★v1.6及以上版本★★
 *     上述插件，都可以在鏡頭縮放時，做相應的變換支持。
 * 
 * -----------------------------------------------------------------------------
 * ----設定注意事項
 * 1.插件的作用域：地圖界面。
 * 鏡頭移動：
 *   (1.彈性移動 和 平滑移動，會對rmmv中的 移動 > 滾動地圖 指令 有影響。
 *      滾動地圖指令結束後會立即彈回玩家中心。
 *      如果要防止彈回中心，你需要修改移動模式為"默認移動"。
 *   (2.平滑移動，穿過循環地圖邊緣時，可能會出現鏡頭不穩定的小問題。
 * 鏡頭縮放/旋轉：
 *   (1.鏡頭縮放/旋轉 改變的只有地圖層貼圖。ui、视窗、圖片都不屬於地圖。
 *   (2.鏡頭縮放/旋轉 最好只作為臨時性的過場動畫使用。
 *   (3.鏡頭縮放 和 鏡頭旋轉 不能 同時使用。
 *   (4.鏡頭稍微旋轉12度，有很多特殊代入效果，比如搖晃的船隻、塌陷的斜坡、
 *      某種震擊地面技能造成的整個世界傾斜的特效。
 *   (5.旋轉、縮放時能夠看見未填充的圖塊邊緣，屬於正常情況。
 *      這是由於rmmv的內部機制，每塊圖塊根據方形鏡頭區域一個個拼上去的。
 *      你可以設定"縮小鏡頭時加強刷新量"，只是會比較消耗計算量。
 *   (6.縮放時，由於事件貼圖是分開渲染的，可能在一體化事件之間出現非常微
 *      小的縫隙（只有1個像素的縫隙），為了避免這些問題，你需要使得縮放的
 *      圖塊為整數。原為48像素，那麼 48*0.500=24，48*0.625=30，這些比例可
 *      以避免縫隙。而比例0.600會造成許多縫隙。
 * 鏡頭翻轉：
 *   (1.鏡頭翻轉分為水平翻轉、垂直翻轉、順時針翻轉、逆時針翻轉。
 *      翻轉後，滑鼠點的位置與圖像是相反的，鍵盤也是相反的。
 *   (2.水平垂直翻轉 和 縮放 原理一樣，可以疊加，但是不能和旋轉同用。
 *      順逆時針翻轉 和 旋轉 原理一樣，可以疊加，但是不能和縮放同用。
 *   (3.鏡頭翻轉同時只能處於一種翻轉狀態。
 *      比如，處於水平翻轉狀態時，其它翻轉動作都無法執行。
 *   (4.鏡頭翻轉時，你可以看到黑色圖塊邊緣，以及離鏡頭較遠的事件。屬正常
 *      現象。
 * 鏡頭鎖定/看向指定位置：
 *   (1.看向指定位置/事件，只對 平滑移動和彈性移動 有效。
 *   (2.鎖定鏡頭後，將不受玩家移動影響，你可以用這種鏡頭設計固定路線。
 *   (3.你可以設定看向指定位置/事件，用於某些遠程操控物體的遊戲環節。
 * 鏡頭牆：
 *   (1.鏡頭牆，只對 平滑移動和彈性移動 有效。
 *   (2.鏡頭牆是一種阻止鏡頭單向上/下/左/右移動的牆，若玩家越過了牆壁線，
 *      則鏡頭將不再受阻止。可以用鏡頭牆設定洞穴中隱藏的房間。
 *   (3.由於鏡頭牆是綁定在事件上的，如果該事件在不斷移動，還可以做機關
 *      逼近的鏡頭地圖。
 *   (4.事件註釋設定不跨事件頁，切換無相關注釋的事件頁後，牆會被關閉。
 * 視野觸發：
 *   (1.當指定事件進入視野範圍內之後，觸發指定的獨立開關。
 *   (2.視野觸發設定跨事件頁，並且長期有效。
 *   (3.視野範圍為固定的矩形區域範圍，只有進入了矩形視野，事件才會被觸發。
 *      通過控制鏡頭縮放的邊角、旋轉的邊角看到的視野事件，都不會被觸發。
 * 
 * -----------------------------------------------------------------------------
 * ----可選設定 - 鏡頭移動
 * 你可以通過插件指令修改鏡頭的模式：
 *
 * 插件指令：>地圖鏡頭 : 設定鏡頭移動模式 : 默認移動
 * 插件指令：>地圖鏡頭 : 設定鏡頭移動模式 : 平滑移動
 * 插件指令：>地圖鏡頭 : 設定鏡頭移動模式 : 彈性移動
 * 插件指令：>地圖鏡頭 : 設定彈性模式移動速度 : 10
 * 插件指令：>地圖鏡頭 : 設定彈性模式鏡頭速度上限 : 24
 * 
 * -----------------------------------------------------------------------------
 * ----可選設定 - 鏡頭縮放/旋轉
 * 你可以通過插件指令設定鏡頭縮放：
 * 
 * 插件指令：>地圖鏡頭 : 縮放X : 1.50 : 時間[60]
 * 插件指令：>地圖鏡頭 : 縮放Y : 1.50 : 時間[60]
 * 插件指令：>地圖鏡頭 : 縮放X : 0.50 : 時間[60]
 * 插件指令：>地圖鏡頭 : 縮放Y : 0.50 : 時間[60]
 * 插件指令：>地圖鏡頭 : 旋轉 : 180 : 時間[60]
 * 
 * 1.縮放前一個數字表示縮放比例，後一個數字表示縮放持續時間，單位幀。
 *   1.50表示鏡頭放大50%，只能看見實際範圍的四分之一。
 *   0.50表示鏡頭縮小50%，能看見實際範圍的四倍。
 *   縮放後永久有效，要記得恢復1.00縮放比例。
 *   比例不要設定太小，不然會出問題。
 * 2.旋轉前一個數字表示旋轉角度，後一個數字表示旋轉持續時間，單位幀。
 *   旋轉正數順時針，也可為負數。
 * 3.縮放 和 旋轉 不能 同時使用。
 * 4.縮放/旋轉變化只有勻速。
 * 
 * -----------------------------------------------------------------------------
 * ----可選設定 - 鏡頭翻轉
 * 你可以通過插件指令設定鏡頭翻轉：
 * 
 * 插件指令：>地圖鏡頭 : 水平翻轉 : 時間[60] : 勻速
 * 插件指令：>地圖鏡頭 : 垂直翻轉 : 時間[60] : 勻速
 * 插件指令：>地圖鏡頭 : 順時針翻轉 : 時間[60] : 勻速
 * 插件指令：>地圖鏡頭 : 逆時針翻轉 : 時間[60] : 勻速
 * 插件指令：>地圖鏡頭 : 水平翻轉 : 時間[60] : 平滑
 * 插件指令：>地圖鏡頭 : 垂直翻轉 : 時間[60] : 平滑
 * 插件指令：>地圖鏡頭 : 順時針翻轉 : 時間[60] : 平滑
 * 插件指令：>地圖鏡頭 : 逆時針翻轉 : 時間[60] : 平滑
 * 插件指令：>地圖鏡頭 : 水平翻轉 : 時間[60] : 彈性
 * 插件指令：>地圖鏡頭 : 垂直翻轉 : 時間[60] : 彈性
 * 插件指令：>地圖鏡頭 : 順時針翻轉 : 時間[60] : 彈性
 * 插件指令：>地圖鏡頭 : 逆時針翻轉 : 時間[60] : 彈性
 * 
 * 插件指令：>地圖鏡頭 : 恢復翻轉 : 時間[60] : 勻速
 * 插件指令：>地圖鏡頭 : 恢復翻轉 : 時間[60] : 平滑
 * 插件指令：>地圖鏡頭 : 恢復翻轉 : 時間[60] : 彈性
 * 
 * 1.數字表示翻轉的時間，單位幀。
 * 2.注意，翻轉只能處於一種狀態。比如順時針翻轉後。其它翻轉指令完全失效。
 *   只有恢復翻轉後，才能進行其它翻轉操作。
 * 
 * -----------------------------------------------------------------------------
 * ----可選設定 - 鏡頭鎖定
 * 你可以通過插件指令設定鏡頭被鎖定在當前位置：
 * 
 * 插件指令：>地圖鏡頭 : 鎖定鏡頭
 * 插件指令：>地圖鏡頭 : 解鎖鏡頭
 * 
 * 插件指令：>地圖鏡頭 : 固定看向 : 本事件
 * 插件指令：>地圖鏡頭 : 固定看向 : 事件[13]
 * 插件指令：>地圖鏡頭 : 固定看向 : 事件變量[13]
 * 插件指令：>地圖鏡頭 : 固定看向 : 玩家位置
 * 插件指令：>地圖鏡頭 : 固定看向 : 位置[20,20]
 * 插件指令：>地圖鏡頭 : 固定看向 : 位置變量[21,22]
 * 插件指令：>地圖鏡頭 : 解除固定看向
 * 
 * 插件指令：>地圖鏡頭 : 立刻看向目標位置
 * 
 * 1.鎖定後的鏡頭完全固定，不受任何干擾。
 * 2.你可以使鏡頭固定看向指定位置的XY座標，不受玩家干擾。
 *   (變量)是指變量的值對應的XY座標。
 *   注意，固定看向位置只對 平滑移動和彈性移動 的鏡頭有效。
 * 3."玩家位置"是指玩家當前的XY座標，固定後不再隨玩家移動。
 * 4.如果上述的兩種插件指令如果同時使用，那麼鎖定鏡頭優先。
 * 5.如果你不想出現鏡頭移動到目標的過程，你可以在設定看向位置後，
 *   執行"立刻看向目標位置"。
 * 
 * -----------------------------------------------------------------------------
 * ----可選設定 - 鏡頭牆
 * 你可以通過事件註釋，設定地圖指定的鏡頭牆：
 * 
 * 事件註釋：=>地圖鏡頭 : 設定鏡頭牆 : 上
 * 事件註釋：=>地圖鏡頭 : 設定鏡頭牆 : 下
 * 事件註釋：=>地圖鏡頭 : 設定鏡頭牆 : 左
 * 事件註釋：=>地圖鏡頭 : 設定鏡頭牆 : 右
 *
 * 1.一個事件充當一面牆，形成一個房間的鏡頭牆，需要四個事件。
 *   一般隱藏房間只需要一面鏡頭牆就可以。
 * 2.一個事件可以設定多面牆，同時含左右鏡頭牆，可以形成隔牆效果。
 *   如果要關閉牆，切換事件頁即可。
 * 
 * -----------------------------------------------------------------------------
 * ----可選設定 - 視野觸發
 * 你可以通過事件註釋，設定指定事件進入視野範圍內觸發：
 * 
 * 事件註釋：=>地圖鏡頭 : 進入視野 : 觸發獨立開關 : A
 * 事件註釋：=>地圖鏡頭 : 離開視野 : 關閉獨立開關 : A
 * 
 * 1.插件固定為進入視野開啟開關，離開視野關閉開關。
 * 2.註釋只能設定一個獨立開關，如果事件頁中同時寫了A開關的註釋 和
 *   B開關的註釋，那麼將以B開關為準。
 * 
 * -----------------------------------------------------------------------------
 * ----插件性能
 * 測試儀器：   4G 內存，Intel Core i5-2520M CPU 2.5GHz 處理器
 *              Intel(R) HD Graphics 3000 集顯 的垃圾筆記本
 *              (筆記本的3dmark綜合分：571，魯大師綜合分：48456)
 * 總時段：     20000.00ms左右
 * 對照表：     0.00ms  - 40.00ms （幾乎無消耗）
 *              40.00ms - 80.00ms （低消耗）
 *              80.00ms - 120.00ms（中消耗）
 *              120.00ms以上      （高消耗）
 * 工作類型：   持續執行
 * 時間複雜度： o(n^2)
 * 測試方法：   去物體管理層、地理管理層、鏡像管理層跑一圈測試。
 * 測試結果：   200個事件的地圖中，消耗為：【18.74ms】
 *              100個事件的地圖中，消耗為：【14.84ms】
 *               50個事件的地圖中，消耗為：【12.37ms】
 * 測試方法2：  建立10個鏡頭牆，測試消耗。
 * 測試結果2：   50個事件的地圖中，消耗為：【14.02ms】
 * 
 * 1.插件只在自己作用域下工作消耗性能，在其它作用域下是不工作的。
 *   測試結果並不是精確值，範圍在給定值的10ms範圍內波動。
 *   更多瞭解插件性能，可以去看看"關於插件性能.docx"。
 * 2.鏡頭牆會稍微增加一點計算量，因為要持續判斷玩家與鏡頭位置。
 * 
 * -----------------------------------------------------------------------------
 * ----更新日誌
 * [v1.0]
 * 完成插件ヽ(*。>Д<)o゜
 * [v1.1]
 * 添加了"縮小鏡頭時加強刷新量"功能。
 * [v1.2]
 * 添加了鏡頭鎖定、看向指定位置功能。
 * [v1.3]
 * 添加了插件性能測試說明。
 * [v1.4]
 * 添加了固定看向事件、鏡頭牆、視野觸發功能。
 * [v1.5]
 * 修改了插件指令格式，並且舊的插件指令仍然可以使用。
 * [v1.6]
 * 添加了縮放時的參數獲取，與相關子插件關聯。
 * 添加了"立刻看向目標位置"功能。
 * [v1.7]
 * 修復了鏡頭在移動過程中，事件抖動的問題。
 * （感謝p1夥伴"開關關"https://rpg.blue/thread-480641-1-1.html。）
 * [v1.8]
 * 修復了鏡頭翻轉時偏移的bug。
 */
 
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//		插件簡稱		LCa（Layer_Camera）
//		臨時全局變量	DrillUp.g_LCa_xxx
//		臨時局部變量	this._drill_LCa_xxx
//		存儲數據變量	$gameSystem._drill_LCa_xxx
//		全局存儲變量	無
//		覆蓋重寫方法	Game_Player.prototype.updateScroll
//
//		工作類型		單次執行
//		時間複雜度		o(n^2)
//		性能測試因素	鏡像管理層
//		性能測試消耗	18.74ms 23.85ms
//		最壞情況		暫無
//		備註			消耗雖然很小，但是總能找到。移動鏡頭、翻轉鏡頭沒有明顯的消耗。
//
//插件記錄：
//		★大體框架與功能如下：
//			地圖鏡頭：
//				->鏡頭移動
//					->平滑移動
//					->彈性移動
//				->鏡頭旋轉
//					->翻轉的鏡頭
//					x->搖晃的鏡頭（不穩定的xy平移）	
//				->鏡頭縮放
//					->縮小圖塊問題
//					->縮放的滑鼠修正
//					->縮放的地圖背景修正（需要放 多層地圖背景 插件後面）
//				->鏡頭鎖定
//					->看向指定的圖塊		
//					->看向指定的事件
//				->鏡頭牆
//				->視野觸發
//
//		★必要注意事項：
//			1.【該插件使用了事件容器】，必須考慮三種情況：初始化、切換地圖時、切換貼圖時，不然會出現指針錯誤！
//				只要是裝事件的容器，都需要考慮指針問題，不管是放在$gameMap還是$gameTemp中。
//				另外，幀刷新判斷時，最好每次變化直接【重刷容器】。
//			2.【該插件的縮放功能近似於核心】，許多子插件都要進行縮放轉換控制，可能會關聯許多與地圖座標相關的內容。
//	
//		★其它說明細節：
//			1.鏡頭實際上只操作 地圖Spriteset_Map（繼承於Spriteset_Base）。
//			2.Spriteset_Map無法設定圓心，所以只能通過修改xy圓形的座標位置，再進行一次逆旋轉。
//			  通過逆旋轉，把圓心0,0變成實際圓心(w/2,h/2)
//			3.另外，這個旋轉、縮放的變化過程，使得翻轉的過程分支了一大堆if，使得代碼變得非常不好看。
//			4.【地圖實際鏡頭，是_displayX控制的】，Spriteset_Map的xy完全屬於例外變量。
//			5.地圖縮小時，刷新範圍是受限的。通過控制下面三個參數來設定。
//				this._tilemap._width
//				this._tilemap._height
//				this._tilemap._margin
//				由於直接觸及到了最底層core，這裡沒有覆寫，只是添加功能。
//
//		★存在的問題：
//			1.翻轉時，會看到圖塊的拼接過程。（縮放已解決，旋轉未處理。）
//			2.由於鏡頭平移關係，目前鏡頭設定偏移量非常麻煩，目前xy相關平移不考慮，以免平移非常難看。
//			3.鏡頭最大的問題，在於圓心的問題。
//			  只有單獨的sprite才能設定圓心，tilemap和循環貼圖都沒有圓心。
//			  旋轉的時候問題也大，這相當於指數形式讓公式越來越複雜（通過數學轉換部分解決，但是仍然存在問題）

//=============================================================================
// ** 變量獲取
//=============================================================================
　　var Imported = Imported || {};
　　Imported.Drill_LayerCamera = true;
　　var DrillUp = DrillUp || {}; 
    DrillUp.parameters = PluginManager.parameters('Drill_LayerCamera');

    DrillUp.g_LCa_type = String(DrillUp.parameters['鏡頭移動模式'] || '彈性移動');
    DrillUp.g_LCa_speedRatio = Number(DrillUp.parameters['彈性模式移動速度'] || 10);
    DrillUp.g_LCa_speedMax = Number(DrillUp.parameters['彈性模式鏡頭速度上限'] || 24);
    DrillUp.g_LCa_forceRefresh = String(DrillUp.parameters['縮小鏡頭時是否加強刷新量'] || "true") == "true";

//=============================================================================
// ** 存儲變量初始化
//=============================================================================
//==============================
// * 初始化
//==============================
var _drill_LCa_sys_initialize = Game_System.prototype.initialize;
Game_System.prototype.initialize = function() {
	_drill_LCa_sys_initialize.call(this);
    this._drill_LCa_type = DrillUp.g_LCa_type ;					//鏡頭移動模式
    this._drill_LCa_speedRatio = DrillUp.g_LCa_speedRatio ;		//移動速度
    this._drill_LCa_speedMax = DrillUp.g_LCa_speedMax ;			//速度上限
	
	this._drill_LCa_sX = {}			// 縮放x
	this._drill_LCa_sX.cur = 0;		//	cur = -0.1，則縮放為0.9
	this._drill_LCa_sX.move = 0;	//
	this._drill_LCa_sX.time = 0;	//
	this._drill_LCa_sY = {}			// 縮放y
	this._drill_LCa_sY.cur = 0;		//
	this._drill_LCa_sY.move = 0;	//
	this._drill_LCa_sY.time = 0;	//
	this._drill_LCa_R = {}			// 旋轉
	this._drill_LCa_R.cur = 0;		//
	this._drill_LCa_R.move = 0;		//
	this._drill_LCa_R.time = 0;		//
	
    this._drill_LCa_flip = {};			//翻轉控制
    this._drill_LCa_flip.lock = false;	//
	
    this._drill_LCa_locked = false;		//固定看向
    this._drill_LCa_lookAt_X = -1;		//看向圖塊x
    this._drill_LCa_lookAt_Y = -1;		//看向圖塊y
    this._drill_LCa_lookAt_event = -1;	//看向事件
};
//==============================
// * 縮放參數
//==============================
Game_System.prototype.drill_LCa_curScaleX = function() {		//當前鏡頭x縮放
	return 1 + this._drill_LCa_sX.cur;
}
Game_System.prototype.drill_LCa_curScaleY = function() {		//當前鏡頭y縮放
	return 1 + this._drill_LCa_sY.cur;
}
Game_System.prototype.drill_LCa_cameraToMapX = function(x) {	//當前鏡頭的x -> 縮放後的x
	var cur_scale = this.drill_LCa_curScaleX();
	x = x / cur_scale;
	x -= (Graphics.boxWidth / cur_scale - Graphics.boxWidth)/2;
	return Math.round(x);
}
Game_System.prototype.drill_LCa_cameraToMapY = function(y) {	//當前鏡頭的y -> 縮放後的y
	var cur_scale = this.drill_LCa_curScaleY();
	y = y / cur_scale;
	y -= (Graphics.boxHeight / cur_scale - Graphics.boxHeight)/2;
	return Math.round(y);
}
Game_System.prototype.drill_LCa_mapToCameraX = function(x) {	//當前縮放的x -> 鏡頭的x
	var cur_scale = this.drill_LCa_curScaleX();
	x += (Graphics.boxWidth / cur_scale - Graphics.boxWidth)/2;
	x = x * cur_scale;
	return Math.round(x);
}
Game_System.prototype.drill_LCa_mapToCameraY = function(y) {	//當前縮放的y -> 鏡頭的y
	var cur_scale = this.drill_LCa_curScaleY();
	y += (Graphics.boxHeight / cur_scale - Graphics.boxHeight)/2;
	y = y * cur_scale;
	return Math.round(y);
}


//=============================================================================
// * 插件指令
//=============================================================================
var _drill_LCa_pluginCommand = Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function(command, args) {
	_drill_LCa_pluginCommand.call(this, command, args);
	
	if (command === '>地圖鏡頭') {
		
		/*-----------------鏡頭鎖定------------------*/
		if(args.length == 2){
			var type = String(args[1]);
			if(type == "鎖定鏡頭"){
				$gameSystem._drill_LCa_locked = true;
			}
			if(type == "解鎖鏡頭"){
				$gameSystem._drill_LCa_locked = false;
			}
			if(type == "解除固定看向"){
				$gameSystem._drill_LCa_lookAt_X = -1;
				$gameSystem._drill_LCa_lookAt_Y = -1;
				$gameSystem._drill_LCa_lookAt_event = -1;
			}
			if(type == "立刻看向目標位置"){
				$gameTemp._drill_LCa_lookAt_immediately = true;
			}
		}
		if(args.length == 4){
			var type = String(args[1]);
			var unit = String(args[3]);
			if( type == "固定看向" ){
				if( unit == "本事件" ){
					var e_id = this._eventId;
					$gameSystem._drill_LCa_lookAt_X = -1;
					$gameSystem._drill_LCa_lookAt_Y = -1;
					$gameSystem._drill_LCa_lookAt_event = e_id;
				}
				if( unit == "玩家位置" ){
					var e_id = this._eventId;
					$gameSystem._drill_LCa_lookAt_X = $gamePlayer.x;
					$gameSystem._drill_LCa_lookAt_Y = $gamePlayer.y;
					$gameSystem._drill_LCa_lookAt_event = -1;
				}
				if( unit.indexOf("事件[") != -1 ){
					unit = unit.replace("事件[","");
					unit = unit.replace("]","");
					var e_id = Number(unit);
					$gameSystem._drill_LCa_lookAt_X = -1;
					$gameSystem._drill_LCa_lookAt_Y = -1;
					$gameSystem._drill_LCa_lookAt_event = e_id;
				}
				if( unit.indexOf("事件變量[") != -1 ){
					unit = unit.replace("事件變量[","");
					unit = unit.replace("]","");
					var e_id = $gameVariables.value(Number(unit));
					$gameSystem._drill_LCa_lookAt_X = -1;
					$gameSystem._drill_LCa_lookAt_Y = -1;
					$gameSystem._drill_LCa_lookAt_event = e_id;
				}
				if( unit.indexOf("位置[") != -1 ){
					unit = unit.replace("位置[","");
					unit = unit.replace("]","");
					var pos = unit.split(/[,，]/);
					if( pos.length >=2 ){
						$gameSystem._drill_LCa_lookAt_X = Number(pos[0]);
						$gameSystem._drill_LCa_lookAt_Y = Number(pos[1]);
						$gameSystem._drill_LCa_lookAt_event = -1;
					}
				}
				if( unit.indexOf("位置變量[") != -1 ){
					unit = unit.replace("位置變量[","");
					unit = unit.replace("]","");
					var pos = unit.split(/[,，]/);
					if( pos.length >=2 ){
						$gameSystem._drill_LCa_lookAt_X = Number(pos[0]);
						$gameSystem._drill_LCa_lookAt_Y = Number(pos[1]);
						$gameSystem._drill_LCa_lookAt_event = -1;
					}
				}
			}
		}
		/*-----------------鏡頭鎖定（舊指令）------------------*/
		if(args.length == 6){
			var type = String(args[1]);
			var temp1 = Number(args[3]);
			var temp2 = Number(args[5]);
			if(type == "固定看向位置"){
				$gameSystem._drill_LCa_lookAt_X = Math.max( temp1 , 0);
				$gameSystem._drill_LCa_lookAt_Y = Math.max( temp2 , 0);
				$gameSystem._drill_LCa_lookAt_event = -1;
			}
			if(type == "固定看向位置(變量)"){
				$gameSystem._drill_LCa_lookAt_X = Math.max( $gameVariables.value(temp1) , 0);
				$gameSystem._drill_LCa_lookAt_Y = Math.max( $gameVariables.value(temp2) , 0);
				$gameSystem._drill_LCa_lookAt_event = -1;
			}
		}
		if(args.length == 4){
			var type = String(args[1]);
			var temp1 = String(args[3]);
			if(type == "固定看向事件"){
				$gameSystem._drill_LCa_lookAt_X = -1;
				$gameSystem._drill_LCa_lookAt_Y = -1;
				$gameSystem._drill_LCa_lookAt_event = Number(temp1);
			}
			if(type == "固定看向事件(變量)"){
				$gameSystem._drill_LCa_lookAt_X = -1;
				$gameSystem._drill_LCa_lookAt_Y = -1;
				$gameSystem._drill_LCa_lookAt_event = $gameVariables.value(Number(temp1));
			}
		}
		/*-----------------鏡頭移動------------------*/
		if(args.length == 4){	 // >地圖鏡頭 : 設定鏡頭移動模式 : 默認移動
			var type = String(args[1]);
			var temp1 = String(args[3]);
			if(type == "設定鏡頭移動模式"){
				$gameSystem._drill_LCa_type = temp1;
			}
			if(type == "設定彈性模式移動速度"){
				$gameSystem._drill_LCa_speedRatio = Number(temp1);
			}
			if(type == "設定彈性模式鏡頭速度上限"){
				$gameSystem._drill_LCa_speedMax = Number(temp1);
			}
		}
		/*-----------------鏡頭縮放/旋轉------------------*/
		if(args.length == 6){
			var type = String(args[1]);
			var temp1 = String(args[3]);
			var temp2 = String(args[5]);
			temp1 = temp1.replace("時間[","");
			temp1 = temp1.replace("]","");
			temp2 = temp2.replace("時間[","");
			temp2 = temp2.replace("]","");
			if( (type == "順時針翻轉" || type == "逆時針翻轉") && $gameSystem._drill_LCa_flip.lock == false){
				$gameSystem._drill_LCa_flip.type = type;
				$gameSystem._drill_LCa_flip.back = false;
				$gameSystem._drill_LCa_flip.mode = temp2;
				$gameSystem._drill_LCa_flip.time = Number(temp1);
				$gameSystem._drill_LCa_flip.move = 0;
				$gameSystem._drill_LCa_flip.lock = true;
			}
			if( (type == "水平翻轉" || type == "垂直翻轉") && $gameSystem._drill_LCa_flip.lock == false){
				$gameSystem._drill_LCa_flip.type = type;
				$gameSystem._drill_LCa_flip.back = false;
				$gameSystem._drill_LCa_flip.mode = temp2;
				$gameSystem._drill_LCa_flip.time = Number(temp1);
				$gameSystem._drill_LCa_flip.move = 0;
				$gameSystem._drill_LCa_flip.lock = true;
			}
			if( type == "恢復翻轉" && $gameSystem._drill_LCa_flip.lock == true ){
				$gameSystem._drill_LCa_flip.back = true;
				$gameSystem._drill_LCa_flip.mode = temp2;
				$gameSystem._drill_LCa_flip.time = Number(temp1);
				$gameSystem._drill_LCa_flip.move = Number(temp1);
			}
			if( type == "縮放X" ){
				$gameSystem._drill_LCa_sX.move = 0;
				$gameSystem._drill_LCa_sX.time = Math.max(Number(temp2),1);
				$gameSystem._drill_LCa_sX.speed = (Number(temp1) -1 - $gameSystem._drill_LCa_sX.cur)/$gameSystem._drill_LCa_sX.time;
			}
			if( type == "縮放Y" ){
				$gameSystem._drill_LCa_sY.move = 0;
				$gameSystem._drill_LCa_sY.time = Math.max(Number(temp2),1);
				$gameSystem._drill_LCa_sY.speed = (Number(temp1) -1 - $gameSystem._drill_LCa_sY.cur)/$gameSystem._drill_LCa_sY.time;
			}
			if( type == "旋轉" ){
				$gameSystem._drill_LCa_R.move = 0;
				$gameSystem._drill_LCa_R.time = Math.max(Number(temp2),1);
				$gameSystem._drill_LCa_R.speed = (Number(temp1) - $gameSystem._drill_LCa_R.cur)/$gameSystem._drill_LCa_R.time;
			}
		}
	}
}

//=============================================================================
// ** 事件註釋初始化
//=============================================================================
var _drill_LCa_c_setupPageSettings = Game_Event.prototype.setupPageSettings;
Game_Event.prototype.setupPageSettings = function() {
	_drill_LCa_c_setupPageSettings.call(this);
	this._drill_LCa_wall = [];		//不跨事件頁
	if(!this._drill_LCa_sightOn) { this._drill_LCa_sightOn = ""; }	//跨事件頁
	if(!this._drill_LCa_sightOff){ this._drill_LCa_sightOff = ""; }
	
	var page = this.page();
    if( page ) {
		this.list().forEach(function(l) {	//將頁面註釋轉成插件指令格式
			if (l.code === 108) {
				var args = l.parameters[0].split(' ');
				var command = args.shift();
				
				if (command == "=>地圖鏡頭" ){
					if( args.length == 4 ){
						if(args[1]){ var type = String(args[1]);}
						if(args[3]){ var temp1 = String(args[3]);}
						if ( type == "設定鏡頭牆"){
							this._drill_LCa_wall.push(temp1);
							$gameTemp._drill_LCa_needRefresh = true;
						}
					}
					if( args.length == 6 ){
						if(args[1]){ var type = String(args[1]);}
						if(args[3]){ var type2 = String(args[3]);}
						if(args[5]){ var temp1 = String(args[5]);}
						if ( type == "進入視野" && type2 == "觸發獨立開關"){
							this._drill_LCa_sightOn = temp1;
							$gameTemp._drill_LCa_needRefresh = true;
						}
						if ( type == "離開視野" && type2 == "關閉獨立開關"){
							this._drill_LCa_sightOff = temp1;
							$gameTemp._drill_LCa_needRefresh = true;
						}
					}
				};  
			};
		}, this);
    }
}

//=============================================================================
// ** 事件容器
//=============================================================================
//==============================
// * 容器 - 初始化
//==============================
var _drill_LCa_temp_initialize = Game_Temp.prototype.initialize;
Game_Temp.prototype.initialize = function() {	
	_drill_LCa_temp_initialize.call(this);
	this._drill_LCa_wallEvents = [];		//含鏡頭牆的事件
	this._drill_LCa_sightEvents = [];		//含視野觸發的事件
	this._drill_LCa_needRefresh = true;
	
	this._drill_LCa_pixel_fix_x = 0;		//像素補正值
	this._drill_LCa_pixel_fix_y = 0;		//
};
//==============================
// * 容器 - 切換地圖時
//==============================
var _drill_LCa_gmap_setup = Game_Map.prototype.setup;
Game_Map.prototype.setup = function(mapId) {
	$gameTemp._drill_LCa_wallEvents = [];		//含鏡頭牆的事件
	$gameTemp._drill_LCa_sightEvents = [];		//含視野觸發的事件
	$gameTemp._drill_LCa_needRefresh = true;
	_drill_LCa_gmap_setup.call(this,mapId);
}
//==============================
// * 容器 - 切換貼圖時（選單界面刷新）
//==============================
var _drill_LCa_smap_createCharacters = Spriteset_Map.prototype.createCharacters;
Spriteset_Map.prototype.createCharacters = function() {
	$gameTemp._drill_LCa_wallEvents = [];
	$gameTemp._drill_LCa_sightEvents = [];
	$gameTemp._drill_LCa_needRefresh = true;
	_drill_LCa_smap_createCharacters.call(this);
}
//==============================
// ** 容器 - 幀刷新
//==============================
var _drill_LCa_map_update = Game_Map.prototype.update;
Game_Map.prototype.update = function(sceneActive) {
	_drill_LCa_map_update.call(this,sceneActive);
	
	this.drill_LCa_refreshSwitchChecks();
};
//==============================
// ** 容器 - 幀刷新 - 刷新統計
//==============================
Game_Map.prototype.drill_LCa_refreshSwitchChecks = function() {
	if( !$gameTemp._drill_LCa_needRefresh ){ return }
	$gameTemp._drill_LCa_needRefresh = false;
	
	var events = this.events();
	$gameTemp._drill_LCa_wallEvents = [];
	$gameTemp._drill_LCa_sightEvents = [];
	for (var i = 0; i < events.length; i++) {  
		var temp_event = events[i];
		if( temp_event._drill_LCa_wall != null && 
			temp_event._drill_LCa_wall.length != 0){
			$gameTemp._drill_LCa_wallEvents.push(temp_event);
		}
		if( temp_event._drill_LCa_sightOn != null && 
			temp_event._drill_LCa_sightOn != "") {
			$gameTemp._drill_LCa_sightEvents.push(temp_event);
		}
		if( temp_event._drill_LCa_sightOff != null && 
			temp_event._drill_LCa_sightOff != "") {
			$gameTemp._drill_LCa_sightEvents.push(temp_event);
		}
	}
}


//=============================================================================
// ** 鏡頭屬性
//=============================================================================
//==============================
// * 鏡頭屬性 - 縮放地圖的滑鼠修正
//==============================
var _drill_LCa_g_canvasToMapX = Game_Map.prototype.canvasToMapX;
Game_Map.prototype.canvasToMapX = function( x ) {
	x = $gameSystem.drill_LCa_cameraToMapX( x );
	console.log(_drill_LCa_g_canvasToMapX.call(this,x))
	return _drill_LCa_g_canvasToMapX.call(this,x);
};

var _drill_LCa_g_canvasToMapY = Game_Map.prototype.canvasToMapY;
Game_Map.prototype.canvasToMapY = function( y ) {
	y = $gameSystem.drill_LCa_cameraToMapY( y );
	return _drill_LCa_g_canvasToMapY.call(this,y);
};

//==============================
// * 鏡頭屬性 - 固定幀初始值
//==============================
var _drill_LCa_updatePosition = Spriteset_Map.prototype.updatePosition;
Spriteset_Map.prototype.updatePosition = function() {
	_drill_LCa_updatePosition.call(this);				// x、y、z、縮放x、縮放y
	if( this.rotation != 0 ){ this.rotation = 0; }		// 旋轉
	if( this.skew.x != 0 ){ this.skew.x = 0; }			// 斜切x
	if( this.skew.y != 0 ){ this.skew.y = 0; }			// 斜切y
														//Spriteset_Map的中心錨點沒有效果，且rotation被鎖定為（0,0）中心點位置，這裡索性固定中心點為(0,0)。
}
//==============================
// * 鏡頭屬性 - 幀刷新
//==============================
var _drill_LCa_updatePosition2 = Spriteset_Map.prototype.updatePosition;
Spriteset_Map.prototype.updatePosition = function() {
	_drill_LCa_updatePosition2.call(this);				
	
	this._drill_LCa_change_rotation = 0;	//旋轉
	this._drill_LCa_change_sizeX = 1;		//縮放x
	this._drill_LCa_change_sizeY = 1;		//縮放y
	
	this.drill_LCa_resize();				//縮放操作
	this.drill_LCa_rotate();				//旋轉操作
	this.drill_LCa_flip();					//翻轉控制
	this.drill_LCa_lockAnchor();			//鎖定錨點
	this.drill_LCa_tileResize();			//圖塊填充（縮放比例適應）
};
//==============================
// * 鏡頭屬性 - 縮放
//==============================
Spriteset_Map.prototype.drill_LCa_resize = function() {
	var re_x = $gameSystem._drill_LCa_sX;
	var re_y = $gameSystem._drill_LCa_sY;
	re_x.move += 1;
	re_y.move += 1;
	
	if( re_x.move <= re_x.time ){ re_x.cur += re_x.speed; }
	if( re_y.move <= re_y.time ){ re_y.cur += re_y.speed; }
	
	if( re_x.move > re_x.time ){ re_x.cur = Number(re_x.cur.toFixed(4)); } //比例吸附（保留4位有效數字）
	if( re_y.move > re_y.time ){ re_y.cur = Number(re_y.cur.toFixed(4)); }
	
	this._drill_LCa_change_sizeX += re_x.cur;
	this._drill_LCa_change_sizeY += re_y.cur;
}
//==============================
// * 鏡頭屬性 - 旋轉
//==============================
Spriteset_Map.prototype.drill_LCa_rotate = function() {
	var re_r = $gameSystem._drill_LCa_R;
	re_r.move += 1;
	
	if( re_r.move <= re_r.time ){
		re_r.cur += re_r.speed;
	}
	
	this._drill_LCa_change_rotation += ( re_r.cur /180.0 )*Math.PI;
}
//==============================
// * 鏡頭屬性 - 鎖定錨點
//==============================
Spriteset_Map.prototype.drill_LCa_lockAnchor = function() {
	
	//if( this._drill_LCa_change_rotation != 0 ){
	//	var ww = Graphics.boxWidth/2;
	//	var hh = Graphics.boxHeight/2;
	//	var r = Math.sqrt( Math.pow(ww,2) + Math.pow(hh,2) );
	//	var p_degree = Math.atan(hh/ww);
	//	p_degree = Math.PI - p_degree;
	//	this.x += r*Math.cos( this._drill_LCa_change_rotation - p_degree);
	//	this.y += r*Math.sin( this._drill_LCa_change_rotation - p_degree);
	//	this.x += Graphics.boxWidth/2 ;
	//	this.y += Graphics.boxHeight/2 ;
	//	this.rotation = this._drill_LCa_change_rotation;
	//}
	//if( this._drill_LCa_change_sizeX != 1 || this._drill_LCa_change_sizeY != 1 ){
	//	this.scale.x = this._drill_LCa_change_sizeX;
	//	this.scale.y = this._drill_LCa_change_sizeY;
	//	this.x += Graphics.boxWidth/2 * (1 - this._drill_LCa_change_sizeX ) ;
	//	this.y += Graphics.boxHeight/2 * (1 - this._drill_LCa_change_sizeY ) ;
	//}
	
	var rotation = this._drill_LCa_change_rotation;
	var scale_x = this._drill_LCa_change_sizeX;
	var scale_y = this._drill_LCa_change_sizeY;
	if( rotation == 0 && scale_x == 1 && scale_y == 1 ){ return; } 
	
	// > 錨點(0.5,0.5)鎖定
	var fix_point = $gameTemp.drill_LCa_getFixPointInAnchor( 0,0, 0.5,0.5, Graphics.boxWidth,Graphics.boxHeight, rotation, scale_x, scale_y );
	this.x += Graphics.boxWidth/2;	
	this.y += Graphics.boxHeight/2;	
	this.x += fix_point.x;	
	this.y += fix_point.y;	
	
	this.rotation = rotation;
	this.scale.x *= scale_x;
	this.scale.y *= scale_y;
}
//=============================================================================
// * 數學 - 鎖定錨點
//			
//			說明：修正 旋轉+縮放 的xy座標，使其看起來像是在繞著 新的錨點 變換。
//=============================================================================
Game_Temp.prototype.drill_LCa_getFixPointInAnchor = function( 
					org_anchor_x,org_anchor_y,			//原貼圖中心錨點 
					target_anchor_x,target_anchor_y, 	//新的中心錨點 
					width, height,						//貼圖高寬
					rotation, scale_x, scale_y ) {		//變換的值（旋轉+縮放）
	
	var ww = width * ( target_anchor_x - org_anchor_x );
	var hh = height * ( target_anchor_y - org_anchor_y );
	var xx = 0;
	var yy = 0;
	if( ww == 0 && hh == 0){ return { "x":0, "y":0 }; }
	if( ww == 0 ){ ww = 0.0001; }
	
	var r = Math.sqrt( Math.pow(ww,2) + Math.pow(hh,2) );
	var p_degree = Math.atan(hh/ww);	
	p_degree = Math.PI - p_degree;
	
	xx = r*Math.cos( rotation - p_degree);		//圓公式 (x-a)²+(y-b)²=r²
	yy = r*Math.sin( rotation - p_degree);		//圓極座標 x=ρcosθ,y=ρsinθ
												//公式正負號修正（大坑）
	
	xx += ww * (1 - scale_x);
	yy += hh * (1 - scale_y);
	
	return { "x":xx, "y":yy };
}
//==============================
// * 鏡頭屬性 - 圖塊填充（縮放比例適應）
//==============================
Spriteset_Map.prototype.drill_LCa_tileResize = function() {
	if( DrillUp.g_LCa_forceRefresh == false ){ return; }
	if( this._drill_LCa_change_sizeX == 1 && this._drill_LCa_change_sizeY == 1 ){ return; }
	
	var _x = Graphics.boxWidth / this.scale.x - Graphics.boxWidth;
	var _y = Graphics.boxHeight / this.scale.y - Graphics.boxHeight;
	var _xx =  Graphics.boxWidth + _x/2*3 ;
	var _yy =  Graphics.boxHeight + _y/2*3 ;
	if( _xx > 0 && _yy > 0 && _x > 0 && _y > 0 ){
		var width = Graphics.boxWidth + 20 * 2;
		var height = Graphics.boxHeight + 20 * 2;
		var wh = Math.max( width / this.scale.x - width , height / this.scale.y - height);
		this._tilemap.margin = wh/2 + 20;
		this._tilemap._width = width / this.scale.x ;
		this._tilemap._height = height / this.scale.y ;
	}
	if( _x == 0 && _y == 0 ){
		var width = Graphics.boxWidth + 20 * 2;
		var height = Graphics.boxHeight + 20 * 2;
		this._tilemap._width = width ;
		this._tilemap._height = height ;
		this._tilemap.margin = 20;
	}
}
//==============================
// * 鏡頭屬性 - margin屬性（圖塊填充）
//==============================
Object.defineProperty(Tilemap.prototype, 'margin', {
    get: function() {
        return this._margin;
    },
    set: function(value) {
        if (this._margin !== value) {
            this._margin = value;
            this._createLayers();
        }
    }
});

//==============================
// * 鏡頭屬性 - 兼容Drill_LayerGround縮放
//==============================
var _drill_LCa_s_update = Scene_Map.prototype.update;
Scene_Map.prototype.update = function (){
	_drill_LCa_s_update.call(this);
	
	if( Imported.Drill_LayerGround && DrillUp.g_LCa_forceRefresh ){
		var _x = Graphics.boxWidth / this._spriteset.scale.x - Graphics.boxWidth;
		var _y = Graphics.boxHeight / this._spriteset.scale.y - Graphics.boxHeight;
		var _xx =  Graphics.boxWidth + _x/2*3 ;
		var _yy =  Graphics.boxHeight + _y/2*3 ;
		if( _xx > 0 && _yy > 0 && _x > 0 && _y > 0 ){
			if( this._drill_LG_spriteTank ){
				for(var i=0; i< this._drill_LG_spriteTank.length; i++){
					var temp_sprite = this._drill_LG_spriteTank[i];
					temp_sprite.move( -1*_x/2 , -1*_y/2 , _xx , _yy );
					temp_sprite.origin.x -= _x/2;
					temp_sprite.origin.y -= _y/2;
				}
			}
			if( this._spriteset._parallax ){
				this._spriteset._parallax.move( -1*_x/2 , -1*_y/2 , _xx , _yy );
				this._spriteset._parallax.origin.x -= _x/2;
				this._spriteset._parallax.origin.y -= _y/2;
			}
		}
	}
}
//==============================
// * 鏡頭屬性 - 翻轉控制
//==============================
Spriteset_Map.prototype.drill_LCa_flip = function() {
	var flip = $gameSystem._drill_LCa_flip;
	
	if(flip.type == "順時針翻轉"){
		if( flip.back == false ){
			if( flip.move < flip.time){ flip.move += 1; }
			if( flip.mode == "彈性"){		//（橢圓公式）
				this._drill_LCa_change_rotation += Math.sqrt((1 - Math.pow( flip.move, 2 )/Math.pow(flip.time,2) ) * Math.pow(Math.PI,2)) - Math.PI;
			}else if(flip.mode == "平滑"){	//（正弦公式）
				this._drill_LCa_change_rotation += Math.PI * Math.sin( flip.move / flip.time * Math.PI/2 );
			}else{	//默認勻速
				this._drill_LCa_change_rotation += Math.PI * flip.move / flip.time ;
			}
		}else{
			if( flip.move > 0 ){ flip.move -= 1; }
			if( flip.move == 0 ){ flip.lock = false; } //清空當前情況
			if( flip.mode == "彈性"){		//（橢圓公式）
				this._drill_LCa_change_rotation += Math.sqrt((1 - Math.pow( flip.move-flip.time , 2 )/Math.pow(flip.time,2) ) * Math.pow(Math.PI,2));
			}else if(flip.mode == "平滑"){	//（正弦公式）
				this._drill_LCa_change_rotation += Math.PI * Math.sin( flip.move / flip.time * Math.PI/2 );
			}else{	//默認勻速
				this._drill_LCa_change_rotation += Math.PI * flip.move / flip.time ;
			}
		}
	}
	if(flip.type == "逆時針翻轉"){
		if( flip.back == false ){
			if( flip.move < flip.time){ flip.move += 1; }
			if( flip.mode == "彈性"){		//（橢圓公式）
				this._drill_LCa_change_rotation += Math.sqrt((1 - Math.pow( flip.move, 2 )/Math.pow(flip.time,2) ) * Math.pow(Math.PI,2)) - Math.PI;
			}else if( flip.mode == "平滑"){	//（正弦公式）
				this._drill_LCa_change_rotation += -Math.PI * Math.sin( flip.move / flip.time * Math.PI/2 );
			}else{	//默認勻速
				this._drill_LCa_change_rotation += -Math.PI * flip.move / flip.time ;
			}
		}else{
			if( flip.move > 0 ){ flip.move -= 1; }
			if( flip.move == 0 ){ flip.lock = false; } //清空當前情況
			if( flip.mode == "彈性" ){		//（橢圓公式）
				this._drill_LCa_change_rotation += Math.sqrt((1 - Math.pow( flip.move-flip.time , 2 )/Math.pow(flip.time,2) ) * Math.pow(Math.PI,2));
			}else if(flip.mode == "平滑"){	//（正弦公式）
				this._drill_LCa_change_rotation += -Math.PI * Math.sin( flip.move / flip.time * Math.PI/2 );
			}else{	//默認勻速
				this._drill_LCa_change_rotation += -Math.PI * flip.move / flip.time ;
			}
		}
	}
	if(flip.type == "水平翻轉"){
		if( flip.back == false ){
			if( flip.move < flip.time){ flip.move += 1; }
			if( flip.mode == "彈性" ){		//（橢圓公式）
				this._drill_LCa_change_sizeX *= Math.sqrt((1 - Math.pow( flip.move, 2 )/Math.pow(flip.time,2) ) * Math.pow(2,2)) - 1;
			}else if( flip.mode == "平滑"){	//（餘弦公式）
				this._drill_LCa_change_sizeX *= Math.cos( Math.PI * flip.move / flip.time );
			}else{	//默認勻速
				this._drill_LCa_change_sizeX *= -2 * flip.move / flip.time + 1;
			}
		}else{
			if( flip.move > 0 ){ flip.move -= 1; }
			if( flip.move == 0 ){ flip.lock = false; } //清空當前情況
			if( flip.mode == "彈性" ){		//（橢圓公式）
				this._drill_LCa_change_sizeX *= Math.sqrt((1 - Math.pow( flip.move, 2 )/Math.pow(flip.time,2) ) * Math.pow(2,2)) - 1;
			}else if( flip.mode == "平滑"){	//（餘弦公式）
				this._drill_LCa_change_sizeX *= Math.cos( Math.PI * flip.move / flip.time );
			}else{	//默認勻速
				this._drill_LCa_change_sizeX *= -2 * flip.move / flip.time + 1;
			}
		}
	}
	if(flip.type == "垂直翻轉"){
		if( flip.back == false ){
			if( flip.move < flip.time){ flip.move += 1; }
			if( flip.mode == "彈性" ){		//（橢圓公式）
				this._drill_LCa_change_sizeY *= Math.sqrt((1 - Math.pow( flip.move, 2 )/Math.pow(flip.time,2) ) * Math.pow(2,2)) - 1;
			}else if( flip.mode == "平滑"){	//（餘弦公式）
				this._drill_LCa_change_sizeY *= Math.cos( Math.PI * flip.move / flip.time );
			}else{	//默認勻速
				this._drill_LCa_change_sizeY *= -2 * flip.move / flip.time + 1;
			}
		}else{
			if( flip.move > 0 ){ flip.move -= 1; }
			if( flip.move == 0 ){ flip.lock = false; } //清空當前情況
			if( flip.mode == "彈性" ){		//（橢圓公式）
				this._drill_LCa_change_sizeY *= Math.sqrt((1 - Math.pow( flip.move, 2 )/Math.pow(flip.time,2) ) * Math.pow(2,2)) - 1;
			}else if( flip.mode == "平滑"){	//（餘弦公式）
				this._drill_LCa_change_sizeY *= Math.cos( Math.PI * flip.move / flip.time );
			}else{	//默認勻速
				this._drill_LCa_change_sizeY *= -2 * flip.move / flip.time + 1;
			}
		}
	}
}

//=============================================================================
// ** 鏡頭移動
//=============================================================================
//==============================
// * 位置刷新
//==============================
var _drill_LCa_updateScroll = Game_Player.prototype.updateScroll;
Game_Player.prototype.updateScroll = function(lastScrolledX, lastScrolledY) {
	// >鎖定鏡頭
	if( $gameSystem._drill_LCa_locked == true ){ return ; }
	// >默認移動
	if( $gameSystem._drill_LCa_type == "默認移動" || $gameMap.isScrolling() ){
		_drill_LCa_updateScroll.call(this,lastScrolledX, lastScrolledY);
		return ;
	}
	// >平滑移動
	if( $gameSystem._drill_LCa_type == "平滑移動" ){
		this.drill_LCa_updateSmoothScroll(lastScrolledX, lastScrolledY);
		return ;
	}
	// >彈性移動
	if( $gameSystem._drill_LCa_type == "彈性移動" ){
		this.drill_LCa_updateSpringScroll(lastScrolledX, lastScrolledY);
		return ;
	}
};
//==============================
// * 平滑移動
//==============================
Game_Player.prototype.drill_LCa_updateSmoothScroll = function(lastScrolledX, lastScrolledY) {
	// >鏡頭位置
	var x1 = lastScrolledX;
	var y1 = lastScrolledY;
	var x2 = this.scrolledX();
	var y2 = this.scrolledY();
	if( $gameSystem._drill_LCa_lookAt_X >= 0 &&		//看向圖塊
		$gameSystem._drill_LCa_lookAt_Y >= 0){
		x2 = $gameMap.adjustX($gameSystem._drill_LCa_lookAt_X);
		y2 = $gameMap.adjustY($gameSystem._drill_LCa_lookAt_Y);
	}
	if( $gameSystem._drill_LCa_lookAt_event >= 0 ){	//看向事件
		x2 = $gameMap.adjustX($gameMap.event($gameSystem._drill_LCa_lookAt_event)._realX);
		y2 = $gameMap.adjustY($gameMap.event($gameSystem._drill_LCa_lookAt_event)._realY);
	}
	
	// >立刻看向目標位置
	if( $gameTemp._drill_LCa_lookAt_immediately == true ){
		$gameTemp._drill_LCa_lookAt_immediately = false;
		if (y2 > this.centerY()){
			var distance = Math.abs(y2 - this.centerY());
			$gameMap.scrollDown( distance );
		}
		if (x2 < this.centerX() ){
			var distance = Math.abs(x2 - this.centerX());
			$gameMap.scrollLeft( distance );
		}
		if (x2 > this.centerX()) {
			var distance = Math.abs(x2 - this.centerX());
			$gameMap.scrollRight( distance );
		}
		if (y2 < this.centerY()){
			var distance = Math.abs(y2 - this.centerY());
			$gameMap.scrollUp( distance );
		}
		return;
	}
	
	// >鏡頭移動
	var halfTileWidth   = $gameMap.tileWidth()/2.0;
	var halfTileHeight   = $gameMap.tileHeight()/2.0;
	var yGrid = this.centerY()*2;
	var xGrid = this.centerX()*2;
	
	if (y2 > this.centerY()){
	  $gameMap.scrollDown(this._realY > $gameMap.height() - this.centerY() ? 
		($gameMap.height() - yGrid - $gameMap.displayY())/halfTileHeight :
		((y2 - yGrid + this.centerY())/halfTileHeight))
	}
	if (x2 < this.centerX() ){
	  $gameMap.scrollLeft(this._realX < this.centerX() ? $gameMap.displayX()/halfTileWidth :
		(($gameMap.displayX() + this.centerX() - this._realX)/halfTileWidth))
	}
	if (x2 > xGrid - this.centerX() ){
	  $gameMap.scrollRight(this._realX > $gameMap.width - this.centerX()  ?
		(($gameMap.width - xGrid) - $gameMap.displayX())/halfTileWidth :
		(x2 - xGrid + this.centerX() )/halfTileWidth)
	}
	if (y2 < this.centerY()){
		$gameMap.scrollUp(this._realY < this.centerY() ?  $gameMap.displayY()/halfTileHeight : 
	  (($gameMap.displayY()+this.centerY()-this._realY)/halfTileHeight))
	}
}

//==============================
// * 彈性移動
//==============================
Game_Player.prototype.drill_LCa_updateSpringScroll = function(lastScrolledX, lastScrolledY) {
	// >鏡頭位置
    var x1 = lastScrolledX;	
    var y1 = lastScrolledY;
    var x2 = this.scrolledX();
    var y2 = this.scrolledY();
	if( $gameSystem._drill_LCa_lookAt_X >= 0 &&		//看向圖塊
		$gameSystem._drill_LCa_lookAt_Y >= 0){
		x2 = $gameMap.adjustX($gameSystem._drill_LCa_lookAt_X);
		y2 = $gameMap.adjustY($gameSystem._drill_LCa_lookAt_Y);
	}
	if( $gameSystem._drill_LCa_lookAt_event >= 0 ){	//看向事件
		x2 = $gameMap.adjustX($gameMap.event($gameSystem._drill_LCa_lookAt_event)._realX);
		y2 = $gameMap.adjustY($gameMap.event($gameSystem._drill_LCa_lookAt_event)._realY);
	}
	
	// >鏡頭牆
	for(var i=0; i<$gameTemp._drill_LCa_wallEvents.length; i++){
		var temp_event = $gameTemp._drill_LCa_wallEvents[i];
		var temp_walls = temp_event._drill_LCa_wall;
		if( !$gameMap.drill_LCa_posIsInCamera(temp_event._realX,temp_event._realY) ){ continue; }//鏡頭內未出現事件，則沒有牆
		
		for(var j=0; j<temp_walls.length; j++){
			if( temp_walls[j] == "左" ){
				if( x2 >= $gameMap.adjustX(temp_event._realX - 0.5 - $gameMap.screenTileX()/2)		//固定貼在事件的左邊線與上邊線
				 && x2 < $gameMap.adjustX(temp_event._realX - 0.5) ){
					x2 = $gameMap.adjustX(temp_event._realX - 0.5 - $gameMap.screenTileX()/2 );
					break;
				}
			}
			if( temp_walls[j] == "右" ){
				if( x2 <= $gameMap.adjustX(temp_event._realX - 0.5 + $gameMap.screenTileX()/2 )
				 && x2 > $gameMap.adjustX(temp_event._realX - 0.5) ){
					x2 = $gameMap.adjustX(temp_event._realX - 0.5 + $gameMap.screenTileX()/2 );
					break;
				}
			}
		}
		for(var j=0; j<temp_walls.length; j++){
			if( temp_walls[j] == "上" ){
				if( y2 >= $gameMap.adjustY(temp_event._realY - 0.5 - $gameMap.screenTileY()/2 )
				 && y2 < $gameMap.adjustY(temp_event._realY - 0.5) ){
					y2 = $gameMap.adjustY(temp_event._realY - 0.5 - $gameMap.screenTileY()/2 );
					break;
				}
			}
			if( temp_walls[j] == "下" ){
				if( y2 <= $gameMap.adjustY(temp_event._realY - 0.5 + $gameMap.screenTileY()/2 )
				 && y2 > $gameMap.adjustY(temp_event._realY - 0.5) ){
					y2 = $gameMap.adjustY(temp_event._realY - 0.5 + $gameMap.screenTileY()/2 );
					break;
				}
			}
		}
	}
	
	// >立刻看向目標位置
	if( $gameTemp._drill_LCa_lookAt_immediately == true ){
		$gameTemp._drill_LCa_lookAt_immediately = false;
		if (y2 > this.centerY()){
			var distance = Math.abs(y2 - this.centerY());
			$gameMap.scrollDown( distance );
		}
		if (x2 < this.centerX() ){
			var distance = Math.abs(x2 - this.centerX());
			$gameMap.scrollLeft( distance );
		}
		if (x2 > this.centerX()) {
			var distance = Math.abs(x2 - this.centerX());
			$gameMap.scrollRight( distance );
		}
		if (y2 < this.centerY()){
			var distance = Math.abs(y2 - this.centerY());
			$gameMap.scrollUp( distance );
		}
		return;
	}
	
	// >鏡頭移動
	var speedRatio_x = $gameSystem._drill_LCa_speedRatio ;
	var speedRatio_y = $gameSystem._drill_LCa_speedRatio ;
	var pixel_speedPlus = 1 / 1000000;	//手動誤差值
	const minPixelSpeed = $gameSystem._drill_LCa_speedMax/7;	//像素最小速度（1/4像素）（SWDA：原本為0.25，最低速度太慢，改為2）
    if (y2 > this.centerY()){
		var distance = Math.abs(y2 - this.centerY());
		var pixel_distance = distance * $gameMap.tileHeight() ;										//像素距離
		var pixel_speed = Math.min(pixel_distance/speedRatio_y,$gameSystem._drill_LCa_speedMax);	//像素速度
		if( pixel_speed < minPixelSpeed ){ pixel_speed = minPixelSpeed; }
																	
		if( pixel_distance < pixel_speed ){							//第一次收斂（最小收斂間距）
			$gameTemp._drill_LCa_pixel_fix_y = 0;					//（鏡頭停止移動後，所有像素必須吻合歸位）
			$gameMap.scrollDown( distance );						//
		}else{							
			pixel_speed += $gameTemp._drill_LCa_pixel_fix_y;							//速度小數位補正
			$gameTemp._drill_LCa_pixel_fix_y = pixel_speed - Math.round(pixel_speed) - pixel_speedPlus;	//補正值
			pixel_speed = Math.round(pixel_speed);										//設定速度為固定像素速度
			pixel_speed += pixel_speedPlus;
			
			if( pixel_distance < pixel_speed ){						//第二次收斂（round鏡頭牆bug）
				$gameTemp._drill_LCa_pixel_fix_y = 0;				//
				$gameMap.scrollDown( distance );					//
			}else{
				$gameMap.scrollDown( pixel_speed/$gameMap.tileHeight() );	
			}
		}   
    }
    if (x2 < this.centerX()) {
		var distance = Math.abs(x2 - this.centerX());
		var pixel_distance = distance * $gameMap.tileWidth() ;
		var pixel_speed = Math.min(pixel_distance/speedRatio_x,$gameSystem._drill_LCa_speedMax);
		if( pixel_speed < minPixelSpeed ){ pixel_speed = minPixelSpeed; }
			
		if( pixel_distance < pixel_speed ){
			$gameTemp._drill_LCa_pixel_fix_x = 0;
			$gameMap.scrollLeft( distance );
		}else{								
			pixel_speed += $gameTemp._drill_LCa_pixel_fix_x;
			$gameTemp._drill_LCa_pixel_fix_x = pixel_speed - Math.round(pixel_speed) + pixel_speedPlus;
			pixel_speed = Math.round(pixel_speed) ;
			pixel_speed -= pixel_speedPlus;
			
			if( pixel_distance < pixel_speed ){			
				$gameTemp._drill_LCa_pixel_fix_x = 0;
				$gameMap.scrollLeft( distance );
			}else{
				$gameMap.scrollLeft( pixel_speed/$gameMap.tileWidth() );
			}
		}
    }
    if (x2 > this.centerX()) {
		var distance = Math.abs(x2 - this.centerX());
		var pixel_distance = distance * $gameMap.tileWidth() ;
		var pixel_speed = Math.min(pixel_distance/speedRatio_x,$gameSystem._drill_LCa_speedMax);
		if( pixel_speed < minPixelSpeed ){ pixel_speed = minPixelSpeed; }
		
		if( pixel_distance < pixel_speed ){
			$gameTemp._drill_LCa_pixel_fix_x = 0;
			$gameMap.scrollRight( distance );
		}else{
			pixel_speed += $gameTemp._drill_LCa_pixel_fix_x;
			$gameTemp._drill_LCa_pixel_fix_x = pixel_speed - Math.round(pixel_speed) - pixel_speedPlus;
			pixel_speed = Math.round(pixel_speed) ;
			pixel_speed += pixel_speedPlus;
			
			if( pixel_distance < pixel_speed ){			
				$gameTemp._drill_LCa_pixel_fix_x = 0;
				$gameMap.scrollRight( distance );
			}else{
				$gameMap.scrollRight( pixel_speed/$gameMap.tileWidth() );
			}
		}
    }
    if (y2 < this.centerY()) {
		var distance = Math.abs(y2 - this.centerY());
		var pixel_distance = distance * $gameMap.tileHeight() ;
		var pixel_speed = Math.min(pixel_distance/speedRatio_y,$gameSystem._drill_LCa_speedMax);
		if( pixel_speed < minPixelSpeed ){ pixel_speed = minPixelSpeed; }
		
		if( pixel_distance < pixel_speed ){	
			$gameTemp._drill_LCa_pixel_fix_y = 0;
			$gameMap.scrollUp( distance );
		}else{		
			pixel_speed += $gameTemp._drill_LCa_pixel_fix_y;
			$gameTemp._drill_LCa_pixel_fix_y = pixel_speed - Math.round(pixel_speed) + pixel_speedPlus;
			pixel_speed = Math.round(pixel_speed) ;
			pixel_speed -= pixel_speedPlus;
			
			if( pixel_distance < pixel_speed ){	
				$gameTemp._drill_LCa_pixel_fix_y = 0;
				$gameMap.scrollUp( distance );
			}else{		
				$gameMap.scrollUp( pixel_speed/$gameMap.tileHeight() );
			}
		}
    }
	
}
//==============================
// * 鏡頭範圍
//==============================
Game_Map.prototype.drill_LCa_posIsInCamera = function(realX, realY) {
	//alert(this.adjustX(realX)+","+this.adjustX(realY));
	return  Math.abs(this.adjustX(realX + 0.5 - this.screenTileX()/2)) <= this.screenTileX()/2 + 0.5 && 
			Math.abs(this.adjustY(realY + 0.5 - this.screenTileY()/2)) <= this.screenTileY()/2 + 0.5 ;
}
 
 
//=============================================================================
// ** 視野觸發
//=============================================================================
//==============================
// ** 視野 - 幀刷新
//==============================
var _drill_LCa_sight_update = Game_Map.prototype.update;
Game_Map.prototype.update = function(sceneActive) {
	_drill_LCa_sight_update.call(this,sceneActive);
	
	this.drill_LCa_updateSightSwitch();
};
Game_Map.prototype.drill_LCa_updateSightSwitch = function() {
	
	// >視野事件
	for(var i=0; i<$gameTemp._drill_LCa_sightEvents.length; i++){
		var temp_event = $gameTemp._drill_LCa_sightEvents[i];
		
		// >事件觸發
		var isTriggered = this.drill_LCa_posIsInCamera(temp_event._realX, temp_event._realY);
		
		// >切換開關
		if(isTriggered){
			var s_key = [this._mapId, temp_event._eventId, temp_event._drill_LCa_sightOn ];
			if( $gameSelfSwitches.value(s_key) !== true){
				$gameSelfSwitches.drill_setValueWithOutChange(s_key,true);
				$gameSelfSwitches.onChange();
			}
		}else{
			var s_key = [this._mapId, temp_event._eventId, temp_event._drill_LCa_sightOff ];
			if( $gameSelfSwitches.value(s_key) !== false){
				$gameSelfSwitches.drill_setValueWithOutChange(s_key,false);
				$gameSelfSwitches.onChange();
			}
		}
	}
}
//==============================
// * 優化 - 獨立開關賦值時不刷新地圖
//==============================
Game_SelfSwitches.prototype.drill_setValueWithOutChange = function(key, value) {
    if (value) {
        this._data[key] = true;
    } else {
        delete this._data[key];
    }
};


